Integrated Application Localization

ABSTRACT

Integrated application localization techniques are described in which support for application localization is provided as an integrated component of a development environment. Localizations for selected languages/locales integrate with application builds in the development environment so that updates are synchronized with project resources for multiple languages. This involves creating and employing localization files corresponding to source content of a project using a designated file format suitable to enable translations. Localization files that are created in the designated format may be exposed in various ways for translation via the system, a developer, a translation service, or other selected translation sources. A single multilingual resource file for an application is then generated to contain resources in multiple languages based on translations made available through the translation sources.

BACKGROUND

Globalization and localization of applications refers to a process of designing and developing applications that function for different languages, cultures, and locales. One challenge associated with creating multilingual applications is handling of translations for different languages and incorporation of the translations for testing of different builds in the development process. Traditionally, integrated development environments (IDEs) provide limited tools for translations and localizations. Thus, developers may be forced to conduct translation related activities on their own (e.g., outside of activities managed by the IDE), which can be time consuming and costly. Moreover, multiple individual language specific resource files corresponding to each selected language are typically maintained for a development project and the developer may have to expend considerable effort each time updates are made to populate the updates across the multiple language specific resource files and obtain translations. These complexities act as barriers that may make it difficult or prohibitive for some developers (e.g., individuals and small entities) to produce multilingual applications.

SUMMARY

Integrated application localization techniques are described in which support for application localization is provided as an integrated component of a development environment. Localizations for selected languages/locales integrate with application builds in the development environment so that updates are synchronized with project resources for multiple languages. This involves creating and employing localization files corresponding to source content of a project using a designated file format suitable to enable translations. Localization files that are created in the designated format may be exposed in various ways for translation via the system, a developer, a translation service, or other selected translation sources. A single multilingual resource file for an application is then generated to contain resources in multiple languages based on translations made available through the translation sources.

This Summary is provided to introduce a selection of concepts in a simplified form that are further described below in the Detailed Description. This Summary is not intended to identify key features or essential features of the claimed subject matter, nor is it intended to be used as an aid in determining the scope of the claimed subject matter.

BRIEF DESCRIPTION OF THE DRAWINGS

The detailed description is described with reference to the accompanying figures. In the figures, the left-most digit(s) of a reference number identifies the figure in which the reference number first appears. The use of the same reference numbers in different instances in the description and the figures may indicate similar or identical items.

FIG. 1 is an illustration of an environment in an example implementation that is operable to employ integrated application localization techniques.

FIG. 2 is a flow diagram depicting a procedure in an example implementation in which a multilingual resource file is generated.

FIG. 3 is a flow diagram depicting a procedure in an example implementation in which application localization is integrated with a build process for an application development project.

FIG. 4 is a flow diagram depicting a procedure in an example implementation in which localization files are created to facilitate translations.

FIG. 5 is a flow diagram depicting a procedure in an example implementation in which available translations are used to form a single multilingual resource file for an application.

FIG. 6 illustrates an example system and components of the system that can be employed to implement embodiments of the techniques described herein.

DETAILED DESCRIPTION

Overview

Traditionally, integrated development environments (IDEs) provide limited tools for translations and localizations of applications to support multiple languages, cultures, locales, and so forth. Thus, developers may be forced to expend considerable effort to obtain translations on their own (e.g., outside of the IDE) and/or populate changes to a project across separate resource files maintained for different languages. These complexities and costs make it difficult or prohibitive for some developers, such as individuals and small entities, to produce multilingual applications.

Integrated application localization techniques are described in which support for application localization is provided as an integrated component of a development environment. Localizations for selected languages/locales integrate with application builds in the development environment so that updates are synchronized with project resources for multiple languages. This involves creating and employing localization files corresponding to source content of a project using a designated file format suitable to enable translations. Localization files that are created in the designated format may be exposed in various ways for translation via the system, a developer, a translation service, or other selected translation sources. A single multilingual resource file for an application is then generated to contain resources in multiple languages based on translations made available through the translation sources.

In the following discussion, an example environment is first described that may employ the techniques described herein. Example procedures are then described which may be performed in the example environment as well as other environments. Consequently, performance of the example procedures is not limited to the example environment and the example environment is not limited to performance of the example procedures. Lastly, an example system and components of the system are described that can be employed in one or more embodiments.

Example Operating Environment

FIG. 1 is an illustration of an environment 100 in an example implementation that is operable to employ techniques described herein. The illustrated environment 100 includes a computing device 102 and a web service 104 that are communicatively coupled via a network 106. The computing device 102 and the web service 104 may each be implemented by a wide range of computing devices.

For example, a computing device 102 may be configured as a computer that is capable of communicating over the network 106, such as a desktop computer, a mobile station, an entertainment appliance, a tablet or slate device, a surface computing device, a set-top box communicatively coupled to a display device, a mobile communication device (e.g., a wireless phone), a game console, and so forth. The computing device 102 may be configured as any suitable computing system and/or device that employ various processing systems, some additional examples of which are discussed in relation to the example system of FIG. 6.

The computing device 102 is further illustrated as including an operating system 108. Generally speaking, the operating system 108 is configured to abstract underlying functionality of the computing device 102 to applications 110 that are executable on the computing device 102. For example, the operating system 108 may abstract processing, memory, network, and/or display functionality of the computing device 102 such that the applications 110 may be written without knowing “how” this underlying functionality is implemented. The application 110, for instance, may provide data to the operating system 108 to be rendered and displayed by the display device without understanding how this rendering will be performed. The operating system 108 may provide various services, interfaces, and functionality that applications 110 may invoke to take advantage of system features. A variety of applications 110 to provide a wide range of functionality to the computing device 102 are contemplated including but not limited to a browser, an office productivity application, an email client, a multi-media management program, device management software, a software development environment, and networking applications, to name a few examples.

The operating system 108 may also represent a variety of other functionality, such as to manage a file system and a user interface that is navigable by a user of the computing device 102. An example of this is illustrated as the user interface configured as an application launcher or start screen (e.g., desktop) for the computing device 102 that is depicted in FIG. 1. The representations or tiles as shown in the illustrated example are selectable to launch a corresponding one of applications 110 for execution on the computing device 102. In this way, a user may readily navigate through a file structure and initiate execution of applications of interest.

The operating system 108 further provides services, interfaces, and functionality for different kinds of applications including “legacy” applications that may be written using statically compiled languages, such as C++, C# and “modern” applications that may be written using dynamic scripting languages, such as JavaScript, hypertext markup language revision 5 and/or cascading style sheets (HTML5/CSS), and extensible application mark-up language (XAML). Modern applications may operate through one or more runtime platforms supported by the operating system 108 that are configured to provide respective execution environments for corresponding applications. Runtime platforms provide a common set of features, routines, and functions for compatible applications thereby offloading coding of common tasks from application development. Thus, runtime platforms can facilitate portability of applications to different kinds of systems with little or no change to the dynamic script for the applications and/or without recompiling. Examples of runtime platforms include JAVA™ runtime environment (JRE), Adobe™ Flash™, Microsoft™.NET framework, Microsoft Silverlight™, and WinRT™, to name a few examples.

The computing device 102 also includes a development module 112 that represents functionality operable to provide an integrated development environment (IDE) for development of applications 110. The development module 112 generally provides application lifecycle management including support for design, development, testing, and/or deployment of applications. The development module 112 may support different programming languages and integrate different components to simplify application development such as a code editor, a compiler, build automation tools, a debugger, and so forth. Thus, the development module 112 provides functionality for a developer to create/edit source content 116 for a project and compile the source content 116 to build an application 110.

In accordance with techniques described herein, the development module 112 may include or otherwise make use of a localization module 114. The localization module 114 represents functionality operable to create and manage translation files for a project from within an IDE. The localization module 114 is further configured to coordinate management and synchronization of project updates across multiple selected languages as resources in a development project are updated. As discussed in greater detail below, the localization module 114 enables developers to create multilingual applications that use a single language resource file. The integration of localization functionality within the IDE implemented via the localization module 114 enables developers to use familiar menus, dialogs, tools, commands, and interfaces to handle translation related activities alongside with application development activities.

In operation, a developer may use the IDE to design, define, create and edit source content 116 (e.g., code, images, styles, annotations, etc.) in a project for an application. In the course of developing the application, a number of builds of the project may occur. The localization module 114 enables the developer to specify multiple languages for translations of the project into different languages. This causes localization files 118 corresponding to each of the specified languages to be created as part of the project. The localization files 118 may correspond to translation projects for each selected language that are linked to or otherwise associated with an application development project and used to store, manage, and update translations 120 for the corresponding application. The localization module 114 implements updating of localization files 118 as part of the build process so that the localization files 118 reflect updates as resources are updated in the project and/or for each build. The localization module 114 may also determine when a string or resource is removed from the project and can remove corresponding translations as part of the update process.

Separate localization files 118 may be created for each additional language selected for a project. A standard, designated file format for the localization files 118 is employed to facilitate translations 120 in various ways and by various translation sources. The designated file format is generally configured to provide a consistent and expected format for project resources that are to be translated. Using a designated file format that is widely accepted and compatible with a variety different translation techniques and sources provides the developer with flexibility to handle translations 120 in many different ways. The localization module 114 may be configured to create localization files 118 in the designated file format and handle conversions of resources, log files, and other data between the designated file format and native, system formats for the operating system 108, IDE, and/or a particular project.

A variety of suitable file formats for handling translations 120 are contemplated. One example file format suitable to implement the described techniques is XLIFF (extensible markup language localization interchange file format). XLIFF is an XML-based format created to standardize exchange of data for localization. XLIFF specifies elements and attributes to aid in localization and can be employed as a transport mechanism for localizable data between compatible processes, systems, and entities. Although XLIFF is used by way of example in various places herein, it is to be appreciated that other formats suitable to transport localizable data for translations may also be employed.

For each build, the localization module 114 may provide and expose localization files 118 to obtain corresponding translations 120. Translations 120 may be generated in any suitable way. For example, localization files 118 may be exported to a web service 104 that includes or makes use of a translation module 122. The translation module 122 represents functionality operable to translate files into designated languages. The translation may include manual translations facilitated via the translation module 122 (e.g. via an editing tool/interface), machine translation techniques, pseudo-translations, and/or combinations thereof Although illustrated as being provided via the web service 104, a translation module 122 may also be provided as a component of the development module 112, as a service accessible through the development module 112, as a standalone application, and so forth. In some embodiments, the localization module 114 may provide an editor module that may be used to edit and translate localization files. When exporting files, the localization module 114 may include the editor module and/or a link to enable downloading of the editor module with the exported files. Thus, the localization module 114 may email or otherwise send out localization files 118 for translation to one or more selected translation sources (e.g., individuals, a pseudo-translation engine, translation services, service providers, etc.) and may optionally include the editor module to facilitate translations by the translation sources.

Additionally the localization module 114 may incorporate a pseudo-translation engine that can be used for localization testing. Pseudo-translation is used to translate a project into a pseudo language to identify translation issues such as hard-coded, concatenated, and/or truncated strings as well as line breaks, spacing problems, visual issues, attribute value translation issues, or other issues that can result in some translations. These kinds of issues may result due to changes in string length and attribute values for elements (generally string growth) that occurs when string are translated. The pseudo-translation engine may be employed to simulate various character, string length, and/or attribute value changes that may result in translation issues. The pseudo-translation engine can therefore operate to produce a pseudo-translation in accordance with techniques described herein. For instance, a pseudo language may be selected by a developer as one of the translation languages for a project. Pseudo-translations into the pseudo language are produced via the pseudo-Microsoft translation engine in XLIFF or another designated format and can be edited in the same manner as other language translations.

As described in detail in relation to the following example procedures, the localization module 114 may consume translations 120 to produce a multilingual application that uses a single resource file for multiple selected languages. In particular, the localization module 114 may integrate creation of multilingual resource files with development via an IDE of modern applications (e.g., applications written using dynamic scripting languages such as XAML, HTML/CSS, and/or Java Script). The same or a different localization module 114 may also be configured to support creation of multilingual resource files for legacy applications. As represented in FIG. 1, a multilingual resource file 124 may be produced via the development module 112 with assistance of the localization module 114 based on translations 120 of localization files 118 exposed to translation sources using XLIFF or another suitable file format. The multilingual resource file 124 is configured to contain translated resources 126 for multiple languages in a single file. The translated resources 126 resources may be updated based upon available translations 120 for each build of the application. In this manner, developers may focus on creating an application in one language and obtain support/functionality for making the application multilingual as an integrated part of the development process with little additional effort.

Having considered an example operating environment, consider now some example procedures for integrated application localization in accordance with one or more embodiments.

Example Procedures

The following discussion describes integrated application localization techniques that may be implemented utilizing the previously described systems and devices. Aspects of each of the procedures may be implemented in hardware, firmware, or software, or a combination thereof The procedures are shown as a set of blocks that specify operations performed by one or more devices and are not necessarily limited to the orders shown for performing the operations by the respective blocks. In portions of the following discussion, reference will be made to the example environment discussed above. In at least some embodiments, the procedures may be performed by a suitably configured computing device, such as the example computing device 102 of FIG. 1 that includes or otherwise makes use of a localization module 114.

FIG. 2 depicts a procedure 200 in an example implementation in which a multilingual resource file is generated. Source content associated with development of an application is converted into localization files having a designated file format for one or more selected languages (block 202). For instance, a development module 112 may provide an IDE that a developer may employ to develop an application. In accordance with techniques described herein the development module 112 may include a localization module 114 to facilitate creation of the application as a multilingual application. The developer is therefore able to select different languages for the application, which causes corresponding localization files to be created for each selected language. For instance, the developer may input selections of languages from a menu or other user interface instrumentality provided in connection with a project for the application. In response to these selections, the localization module 114 may create sub-projects for each selected language. The sub-projects may include respective localization files 118 to contain resources that are updated and translated as an integrated part of the development process. The localization files 118 may be implemented via XLIFF or another designated file format used to facilitate translations. During the build process for the application, existing localization files 118 in a project may be automatically updated with changes made to source content in the project and/or new localization files for selected languages may be created. This may involve conversions of resources and data between a native or system format used by the IDE for the project and the designated file format. Additional details regarding creation of localization files 118 are discussed below in relation to example procedures of FIG. 3 and FIG. 4.

The localization files are exposed in the designated format for translation (block 204). For instance, localization files 118 that are updated to reflect changes made during a build may be exposed for translation in various ways. As mentioned, a variety of techniques and translation sources may be employed to conduct translations. For example, a developer may input selections via the localization module 114 to export localization files 118 to a selected local or network storage location, send files to recipients via email or other communications, invoke a integrated translator of the system or a remote web service 104 configured to perform translations, launch an editor module to perform manual translations, or otherwise interact with one or more translation sources to initiate and/or perform translations of the localization files 118.

Translations that are available are obtained for the localization files from a translation source (block 206). Translations may be driven by the build process in the sense that localization files 118 used for translations are produced as a part of the build process. The actual translations, though, may be performed asynchronously so that the build process is not delayed while waiting for translations. Translations initiated in a particular build may not be ready for incorporation in the application until a subsequent build. Accordingly, the localization module 114 may be configured to check for available translations during each build and obtain/incorporate available translations that are completed based on previous builds. Translations 120 produced by and/or returned from translation sources may be stored in a particular storage location that is accessible by the localization module 114 to obtain available translations. The translations 120 may be provided in XLIFF or another suitable file format as discussed previously.

Resources for which translations are available may be incorporated in a multilingual resource file during a particular build. If translations for resources or languages are not available, however, then incorporation of those resources or languages does not occur until translations are available (e.g., in a subsequent build). Thus, the process of updating localization files 118 with changes, obtaining corresponding translations, and incorporating language specific resources into an application build may involve multiple build passes. Additional details regarding incorporation of translated resources for multiple languages are discussed below in relation to example procedure of FIG. 5.

A multilingual resource file is generated for the application that is configured to contain resources in the one or more selected languages using the obtained translations (block 208). Here, translated resources that are available from translations 120 corresponding to one or more languages may be extracted and/or added to a log that describes multilingual resources for the corresponding application. The localization module 114 may operate to convert resources described in XLIFF (or other standard format) back into a native system format. The localization module 114 combines translated resources 126 for multiple languages to form a single multilingual resource file 124 for the application. Thus, the localization module 114 coordinates updates across multiple languages and automatically synchronizes inclusion of available translations into a multilingual resource file. Additional aspects of techniques for integrated application localization are discussed in relation to the following figures.

FIG. 3 depicts a procedure 300 in an example implementation in which application localization is integrated with a build process for an application development project. Source content of a project for a build of an application under development is compiled (block 302). For instance, a compiler of a development module 112 may be invoked to compile the project. A log file is created in a system format that describes resources for the compiled project (block 304). For example, the development module 112 by may create a log file that logs resources for a particular build. The log file reflects any changes made to the source content for the project and corresponding resources. The log file may be output in a native, system format for the IDE, operating system 108, and/or particular project.

The log file is transformed from the system format to a designated format established for translations (block 306). To do so, the localization module 114 may be configured to convert the log file to a designated format, such as XLIFF. The transformation creates a source resource file for the project that can be employed to update language specific localization files 118. Thus, a common source resource file may be used to populate changes to localization files 118 corresponding to multiple different languages.

In particular, localization files that are included in the project for translations of the application into one or more languages selected for the project are updated (block 308). As mentioned, different localization files may be included in a project for different languages selected by a developer. These target files may use a file format that is designated for translations, such as XLIFF. The source resource file may be used to update the different target localization files with any changes for the build. This may include updating localization files that reflect previous translations and/or populating localization files for newly selected languages with resources described in the source resource file. In general, modifications, additions, or deletions of resources described by the source resource file may be merged with the localization files to produce updated localization files. Resources that have already been translated and have not changed, though, are preserved in the updated localization files to avoid having to re-translate these resources. Updated localization files may then be exposed for translation in various ways as discussed above and below.

Updated localization files in the project for which translations are available are converted from the designated format back into a system format (block 310) and a multilingual resource file for the application is produced that incorporates the translations (block 312). Here, for the particular build, the localization module 114 may obtain available translated resources 126 and incorporate the translated resources 126 into a multilingual resource file 124 for the corresponding application. Translation activities may be conducted using a designated file format such as XLIFF. Thus, the incorporation of translated resources into an application involves conversion of translations from the designated file format back into an appropriate system format for the multilingual resource file 124. The localization module 114 is configured to determine resources to include in the multilingual resource file based on available translations and handle the conversions.

FIG. 4 is a flow diagram depicting a procedure 400 in an example implementation in which localization files are created to facilitate translations. One or more languages are ascertained that are designated for translations of an application under development (block 402). For example, a developer may select multiple languages for a project as mentioned previously. This may occur at various times including when the project is initiated, as part of source content creation/editing, during a build, and so forth. Selection of different languages for a project may cause association of sub-projects (e.g., translation projects) with the project that are configured to contain corresponding localization files 118 for different languages. The project may include data indicative of the selected languages that the localization module 114 may reference to recognize languages designated for the project. In one approach, localization files 118 may be created in the project as languages are selected. Initially, the localization files 118 may be placeholders that contain little or no data regarding project resources. The localization files 118 may then be populated with data during builds as described above and below. In another approach, creation of localization files for newly designated languages occurs as part of the updating process performed during builds. In this case, pre-existing files for some languages may be updated and data indicative of newly selected languages in the project may be used to trigger creation of corresponding localization files 118.

Updated localization files are created for each of the designated languages in a designated format established to facilitate translations (block 404). This may occur in any suitable way. In general, the localization module 114 may perform processing during a build to identify resources that are “localizable” and produce corresponding localization files. In other words, the localization module 114 may distinguish between data such as elements, strings, and tags for a project that are to be translated, e.g., localizable resources, and other data of the project that may not be suitable for translation such as language-neutral terms, proper names, universal code, numbers, and so forth. Separation of localizable resources in this manner serves to simplify the translation process and avoid unnecessary processing. In some embodiments, a pseudo translation engine may be employed by the localization module 114 to assist in recognition of localizable resources. The localization module 114 may also parse metadata associated with resources (e.g., comments, resource IDs, categorization data, tags, etc.) to support recognition of localizable resources and creation of translations via an editor module or other translation source. Metadata for example may include particular tags or other data that the localization module 114 can reference to perform and control automated processes for pseudo translation, machine translation, and/or validation of translated resources.

One example approach to create updated localization files is represented by sub-blocks of block 404 in FIG. 4. In particular, a log file is produced in a system format that describes resources for a build of the applications (block 406) and the log file is parsed to identify and extract localizable resources in the build (block 408). The extracted localized resources are then converted to generate a source resource file for the build in the standard format (block 410).

The log file in this case may be a default file that is produced as part of the build to describe corresponding resources of an application. Accordingly, the log file may be generated in an appropriate system format used for the build/project. The localization module 114 may operate to parse the log file to identify resources for translation based on metadata, tags, or other suitable data associated with resources in the log file. The localization module 114 may also extract these “localizable” resources to separate the localizable resources out from other resources. Additionally, the localization module 114 converts the localizable resources described in the log file to a suitable standard format (e.g., XLIFF) that is used for translations. This produces a source resource file that can be employed to update, create, and/or populate localization files 118 for the one or more languages that are ascertained per block 402.

The source resource file is merged with target localization files included in the project for the one or more languages to form localization files that are updated for the build (block 412). This may include populating changes to existing localization files and/or creating new localization files for different languages. To merge the files, resources are compared between the source resource file and each target localization file to find matching resources (block 414). The comparison may be used to identify items that have been added or changed. In addition, resources that have been previously translated may also be identified. If a localization file for a designated language does not exist, the localization module 114 may create a new localization file in the project. Then, resources in the source resource file are updated with matching resources from the target localization file (block 416). The resulting merged files may be saved as updated versions of the localization files that may replace the previous target files. Any changes and additions are therefore populated to the various localization files. Resources that have not changed may be retained and translations for source resources that have been removed may be deleted. Further, previous translations of matching resources from the target files may be merged into the updated versions. The output of this process is updated localization files for each of the designated languages that reflect changes made for the build and may include any previous translations. The updated localization files may be translated and incorporated into an application in various ways, some examples of which are discussed above and below.

FIG. 5 is a flow diagram depicting a procedure 500 in an example implementation in which available translations are used to form a single multilingual resource file for an application. Localization files are produced that are associated with multiple languages selected for a project to enable translations of a corresponding application by a translation source (block 502). For instance, updated localization files for selected languages may be created via a localization module 114 in various ways described in relation to the previous figures. In at least some embodiments, localization files 118 are produced using XLIFF. The XLIFF file format is one example of a format suitable to enable translation by a variety of translation sources. Accordingly, a developer may choose to perform translations in various ways using XLIFF or another designated format. Translated files resulting from the translations may be stored in a database or other file storage location accessible to the localization module 114. The localization module 114 may then consume the translated files to construct a multilingual resource file for the project.

In particular, translations that are available for resources described in the localization files are combined to produce a multilingual resource file having translated resources for the multiple languages (block 504). This may occur in any suitable way. For example, the localization module 114 may check for available translations during each build of an application and use available translations to create a corresponding resource file. In one approach to combining available translations, a determination is made regarding whether a translation is available for each resource (block 506). For instance, the localization module 114 may examine and process XLIFF files for each language that are included in the project to discover translated resources. Then, translated resources for available translations are incorporated into the multilingual resource file (block 508). The incorporation of translated resource may generally involve creation of a log of various translated resources based on examination of the XLIFF files and conversion of the log from XLIFF (or another selected format) back into a system format associated with the application development. In this manner, a single multilingual resource file containing resources for multiple languages may be created for an application. The multilingual resource file may facilitate testing of the application during different builds and in different languages. Additionally, the multilingual resource file may be published with a completed version of the application to enable multilingual deployment and use.

Having considered example procedures for integrated application localization techniques, consider now a discussion of an example system and components that can be employed to implement embodiments of the techniques described herein.

Example System

FIG. 6 illustrates an example system 600 that includes an example computing device 602 that is representative of one or more computing systems and/or devices that may implement the various techniques described herein. The computing device 602 may be, for example, a server of a service provider, a device associated with a client (e.g., a client device), an on-chip system, and/or any other suitable computing device or computing system.

The example computing device 602 as illustrated includes a processing system 604, one or more computer-readable media 606, and one or more I/O interfaces 608 that are communicatively coupled, one to another. Although not shown, the computing device 602 may further include a system bus or other data and command transfer system that couples the various components, one to another. A system bus can include any one or combination of different bus structures, such as a memory bus or memory controller, a peripheral bus, a universal serial bus, and/or a processor or local bus that utilizes any of a variety of bus architectures. A variety of other examples are also contemplated, such as control and data lines.

The processing system 604 is representative of functionality to perform one or more operations using hardware. Accordingly, the processing system 604 is illustrated as including hardware elements 610 that may be configured as processors, functional blocks, and so forth. This may include implementation in hardware as an application specific integrated circuit or other logic device formed using one or more semiconductors. The hardware elements 610 are not limited by the materials from which they are formed or the processing mechanisms employed therein. For example, processors may be comprised of semiconductor(s) and/or transistors (e.g., electronic integrated circuits (ICs)). In such a context, processor-executable instructions may be electronically-executable instructions.

The computer-readable media 606 is illustrated as including memory/storage 612. The memory/storage 612 represents memory/storage capacity associated with one or more computer-readable media. The memory/storage 612 may include volatile media (such as random access memory (RAM)) and/or nonvolatile media (such as read only memory (ROM), Flash memory, optical disks, magnetic disks, and so forth). The memory/storage 612 may include fixed media (e.g., RAM, ROM, a fixed hard drive, and so on) as well as removable media (e.g., Flash memory, a removable hard drive, an optical disc, and so forth). The computer-readable media 606 may be configured in a variety of other ways as further described below.

Input/output interface(s) 608 are representative of functionality to allow a user to enter commands and information to computing device 602, and also allow information to be presented to the user and/or other components or devices using various input/output devices. Examples of input devices include a keyboard, a cursor control device (e.g., a mouse), a microphone for voice operations, a scanner, touch functionality (e.g., capacitive or other sensors that are configured to detect physical touch), a camera (e.g., which may employ visible or non-visible wavelengths such as infrared frequencies to detect movement that does not involve touch as gestures), and so forth. Examples of output devices include a display device (e.g., a monitor or projector), speakers, a printer, a network card, tactile-response device, and so forth. Thus, the computing device 602 may be configured in a variety of ways as further described below to support user interaction.

Various techniques may be described herein in the general context of software, hardware elements, or program modules. Generally, such modules include routines, programs, objects, elements, components, data structures, and so forth that perform particular tasks or implement particular abstract data types. The terms “module,” “functionality,” and “component” as used herein generally represent software, firmware, hardware, or a combination thereof. The features of the techniques described herein are platform-independent, meaning that the techniques may be implemented on a variety of commercial computing platforms having a variety of processors.

An implementation of the described modules and techniques may be stored on or transmitted across some form of computer-readable media. The computer-readable media may include a variety of media that may be accessed by the computing device 602. By way of example, and not limitation, computer-readable media may include “computer-readable storage media” and “communication media.”

“Computer-readable storage media” may refer to media and/or devices that enable persistent and/or non-transitory storage of information in contrast to mere signal transmission, carrier waves, or signals per se. Thus, computer-readable storage media refers to non-signal bearing media. The computer-readable storage media includes hardware such as volatile and non-volatile, removable and non-removable media and/or storage devices implemented in a method or technology suitable for storage of information such as computer readable instructions, data structures, program modules, logic elements/circuits, or other data. Examples of computer-readable storage media may include, but are not limited to, RAM, ROM, EEPROM, flash memory or other memory technology, CD-ROM, digital versatile disks (DVD) or other optical storage, hard disks, magnetic cassettes, magnetic tape, magnetic disk storage or other magnetic storage devices, or other storage device, tangible media, or article of manufacture suitable to store the desired information and which may be accessed by a computer.

“Communication media” may refer to a signal-bearing medium that is configured to transmit instructions to the hardware of the computing device 602, such as via a network. Communication media typically may embody computer readable instructions, data structures, program modules, or other data in a modulated data signal, such as carrier waves, data signals, or other transport mechanism. Communication media also include any information delivery media. The term “modulated data signal” means a signal that has one or more of its characteristics set or changed in such a manner as to encode information in the signal. By way of example, and not limitation, communication media include wired media such as a wired network or direct-wired connection, and wireless media such as acoustic, RF, infrared, and other wireless media.

As previously described, hardware elements 610 and computer-readable media 606 are representative of instructions, modules, programmable device logic and/or fixed device logic implemented in a hardware form that may be employed in some embodiments to implement at least some aspects of the techniques described herein. Hardware elements may include components of an integrated circuit or on-chip system, an application-specific integrated circuit (ASIC), a field-programmable gate array (FPGA), a complex programmable logic device (CPLD), and other implementations in silicon or other hardware devices. In this context, a hardware element may operate as a processing device that performs program tasks defined by instructions, modules, and/or logic embodied by the hardware element as well as a hardware device utilized to store instructions for execution, e.g., the computer-readable storage media described previously.

Combinations of the foregoing may also be employed to implement various techniques and modules described herein. Accordingly, software, hardware, or program modules including operating system 108, applications 110, development module 112, localization module 114 and other program modules may be implemented as one or more instructions and/or logic embodied on some form of computer-readable storage media and/or by one or more hardware elements 610. The computing device 602 may be configured to implement particular instructions and/or functions corresponding to the software and/or hardware modules. Accordingly, implementation of modules as a module that is executable by the computing device 602 as software may be achieved at least partially in hardware, e.g., through use of computer-readable storage media and/or hardware elements 610 of the processing system. The instructions and/or functions may be executable/operable by one or more articles of manufacture (for example, one or more computing devices 602 and/or processing systems 604) to implement techniques, modules, and examples described herein.

As further illustrated in FIG. 6, the example system 600 enables ubiquitous environments for a seamless user experience when running applications on a personal computer (PC), a television device, and/or a mobile device. Services and applications run substantially similar in all three environments for a common user experience when transitioning from one device to the next while utilizing an application, playing a video game, watching a video, and so on.

In the example system 600, multiple devices are interconnected through a central computing device. The central computing device may be local to the multiple devices or may be located remotely from the multiple devices. In one embodiment, the central computing device may be a cloud of one or more server computers that are connected to the multiple devices through a network, the Internet, or other data communication link.

In one embodiment, this interconnection architecture enables functionality to be delivered across multiple devices to provide a common and seamless experience to a user of the multiple devices. Each of the multiple devices may have different physical requirements and capabilities, and the central computing device uses a platform to enable the delivery of an experience to the device that is both tailored to the device and yet common to all devices. In one embodiment, a class of target devices is created and experiences are tailored to the generic class of devices. A class of devices may be defined by physical features, types of usage, or other common characteristics of the devices.

In various implementations, the computing device 602 may assume a variety of different configurations, such as for computer 614, mobile 616, and television 618 uses. Each of these configurations includes devices that may have generally different constructs and capabilities, and thus the computing device 602 may be configured according to one or more of the different device classes. For instance, the computing device 602 may be implemented as the computer 614 class of a device that includes a personal computer, desktop computer, a multi-screen computer, laptop computer, netbook, and so on.

The computing device 602 may also be implemented as the mobile 616 class of device that includes mobile devices, such as a mobile phone, portable music player, portable gaming device, a tablet computer, a multi-screen computer, and so on. The computing device 602 may also be implemented as the television 618 class of device that includes devices having or connected to generally larger screens in casual viewing environments. These devices include televisions, set-top boxes, gaming consoles, and so on.

The techniques described herein may be supported by these various configurations of the computing device 602 and are not limited to the specific examples of the techniques described herein. This is illustrated through inclusion of the localization module 114 on the computing device 602. The functionality of the localization module 114 and other modules may also be implemented all or in part through use of a distributed system, such as over a “cloud” 620 via a platform 622 as described below.

The cloud 620 includes and/or is representative of a platform 622 for resources 624. The platform 622 abstracts underlying functionality of hardware (e.g., servers) and software resources of the cloud 620. The resources 624 may include applications and/or data that can be utilized while computer processing is executed on servers that are remote from the computing device 602. Resources 624 can also include services provided over the Internet and/or through a subscriber network, such as a cellular or Wi-Fi network.

The platform 622 may abstract resources and functions to connect the computing device 602 with other computing devices. The platform 622 may also serve to abstract scaling of resources to provide a corresponding level of scale to encountered demand for the resources 624 that are implemented via the platform 622. Accordingly, in an interconnected device embodiment, implementation of functionality described herein may be distributed throughout the system 600. For example, the functionality may be implemented in part on the computing device 602 as well as via the platform 622 that abstracts the functionality of the cloud 620.

CONCLUSION

Although the invention has been described in language specific to structural features and/or methodological acts, it is to be understood that the invention defined in the appended claims is not necessarily limited to the specific features or acts described. Rather, the specific features and acts are disclosed as example forms of implementing the claimed invention. 

What is claimed is:
 1. A method implemented by a computing device, the method comprising: converting source content associated with development of an application into localization files having a designated file format for one or more selected languages; exposing the localization files in the designated format for translation; obtaining translations available for the localization files from a translation source; and generating a multilingual resource file for the application configured to contain resources in the one or more selected language using the obtained translations.
 2. A method as described in claim 1, wherein the designated file format comprises extensible markup language localization interchange file format (XLIFF).
 3. A method as described in claim 1, wherein the converting, exposing, obtaining, and generating are performed via a localization module provided as a component of an integrated development environment (IDE).
 4. A method as described in claim 1, wherein converting the source content comprises producing separate localization files in the designated format for each selected language that reflect updates made to the source content for a build of the application.
 5. A method as described in claim 1, wherein the application comprises a modern application that is written using a dynamic scripting language and operates through a corresponding runtime platform.
 6. A method as described in claim 1, wherein exposing the localization files in the designated format for translation comprises exporting the localization files to a selected storage location and invoking a translator to perform translations of the localization files.
 7. A method as described in claim 1, wherein the localization files are automatically updated with changes made to the source content during builds of the application.
 8. A method as described in claim 7, wherein translations of updated localization files produced during a particular build of the application are performed asynchronously with the particular build.
 9. A method as described in claim 1, wherein generating the multilingual resource file comprises extracting translated resources from the available translations, converting the translated resources that are extracted from the designated file format into a system format used for development of the application, and combining the translated resources to form the multilingual resource file.
 10. A method as described in claim 1, wherein converting the source content comprises producing a log file in a system format that describes resources associated with a build of the application and transforming the log file into a source resource file in the designated format used to populate changes made to the source content for the build to the localization files for the selected languages.
 11. One or more computer-readable storage media storing instructions that, when executed by a computing device, implement a localization module configured to perform operations comprising: compiling source content of a project for a build of an application under development; creating a log file in a system format that describes resources for the project; transforming the log file from the system format to a designated file format established for translations; updating localization files included in the project for translations of the application into multiple languages designated for the project using the transformed log file; converting the updated localization files in the project for which translations are available from the designated file format back into the system format; and producing a multilingual resource file for the application that incorporates translated resources from the available translations.
 12. One or more computer-readable storage media as described in claim 11, wherein the designated file format comprises extensible markup language localization interchange file format (XLIFF).
 13. One or more computer-readable storage media as described in claim 11, wherein updating comprises merging changes described by the transformed log file with localization files included in the project for each of the multiple languages.
 14. One or more computer-readable storage media as described in claim 11, wherein one of the multiple languages designated for the project is a pseudo language and the localization module is further configured to translate the project into the pseudo language via a pseudo-translation engine.
 15. One or more computer-readable storage media as described in claim 11, wherein transforming the log file comprises creating a common source resource file used to populate changes across the localization files for multiple languages included in the project.
 16. A computing device comprising: a processing system; one or more modules operable at least in part via hardware of the processing system to implement an integrated development environment (IDE) configured to: ascertain one or more languages selected by developer for translations of an application under development using the IDE; and during a build of the application via the IDE, create updated localization files for each of the selected languages in a designated file format established to facilitate translations used to generate a single multilingual resource file for the application.
 17. The computing device of claim 16, wherein the integrated development environment (IDE) is further configured to: output the updated localization files that are created to enable asynchronous translations via one or more translation sources; obtain translations of localization files that are available during the build; and generate the single multilingual resource file for the build of the application based on the available translations that are obtained.
 18. The computing device of claim 16, wherein the designated file format comprises extensible markup language localization interchange file format (XLIFF).
 19. The computing device of claim 16, wherein creation of the updated localization files comprises: producing a log file in a system format that describes resources for the build of the application; parsing the log file to identify and extract localizable resources in the build; converting the extracted localizable resources to generate a source resource file for the build in the designated file format; and merging the source resource file with target localization files included in the project for the one or more languages to form localization files that are updated for the build.
 20. The computing device of claim 19, wherein the merging comprises, for each target localization file: comparing resources between the source resource file and the target localization file to find matching resources; and updating the resources in the source resource file with matching resources from the target localization file to form an updated version of the target localization file that incorporates modifications to resources for the build from the source resource file and previously translated resources from the target localization file. 